// 版权所有2010 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 表示使用本机Go类型的JSON数据结构：布尔型、浮点型、
// 字符串、数组和映射。

package json

import (
	"encoding"
	"encoding/base64"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"unicode"
	"unicode/utf16"
	"unicode/utf8"
)

// Unmarshal解析JSON编码的数据，并将结果
// 存储在v指向的值中。如果v为零或不是指针，
// Unmarshal将返回一个无效的Unmarshal错误。
// 
// Unmarshal使用与
// Marshal使用的编码相反的编码，根据需要分配映射、切片和指针，
// 。在这种情况下，Unmarshal将
// 指针设置为nil。否则，Unmarshal将JSON解组为
// 指针指向的值。如果指针为nil，Unmarshal 
// 为指针分配一个新值。
// 
// 要将JSON解组为实现解组器接口的值，
// 解组器调用该值的解组JSON方法，包括输入为JSON null时的
// 方法。
// 否则，如果该值实现了编码。TextUnmarshaler 
// 输入是一个带JSON引号的字符串，Unmarshal用字符串的非引号形式调用该值的
// UnmarshalText方法。
// 
// 要将JSON解组到结构中，解组将传入对象
// 键与封送所使用的键（结构字段名或其标记）匹配，
// 更喜欢精确匹配，但也接受不区分大小写的匹配。默认情况下，没有相应结构字段的对象键将被忽略（参见Decoder.disallowunknowfields以获取替代信息）。
// 
// 要将JSON解组为接口值，
// 解组将其中一个存储在接口值中：
// 
// bool，对于JSON布尔型
// float64，对于JSON数字
// string，对于JSON字符串
// []接口}，对于JSON数组
// nil对于JSON null 
// 
// 要将JSON数组解组到切片中，解组将切片长度
// 重置为零，然后将每个元素追加到切片中。
// 作为特例，要将空JSON数组解组为一个切片，
// 解组将该切片替换为一个新的空切片。
// 
// 要将JSON数组解组为Go数组，解组将
// JSON数组元素解码为相应的Go数组元素。
// 如果Go数组小于JSON数组，
// 则丢弃额外的JSON数组元素。
// 如果JSON数组小于Go数组，则
// 额外的Go数组元素设置为零值。
// 
// 要将JSON对象解组到映射中，解组首先建立一个映射到
// use。如果映射为nil，则解组分配一个新映射。否则，Unmarshal 
// 重用现有映射，保留现有条目。解组然后将来自JSON对象的
// 键值对存储到映射中。映射的键类型必须是
// 或者是任意字符串类型，或者是整数，或者是json。解组器，或
// 实现编码。文本解压器。
// 
// 如果一个JSON值不适合给定的目标类型，
// 或者如果一个JSON数溢出了目标类型，Unmarshal 
// 将跳过该字段并尽可能完成解组。
// 如果没有遇到更严重的错误，Unmarshal返回
// 一个UnmarshalTypeError，描述最早的此类错误。在任何
// 情况下，都不能保证问题字段后面的所有剩余字段都会被解组到目标对象中。
// 
// 通过将Go值设置为零，JSON空值将解组到接口、映射、指针或切片
// 中。因为null在JSON中经常被用来表示
// /`not present'，所以将JSON null解组到任何其他Go类型中都不会对值产生影响，也不会产生错误。
// 
// 在对带引号的字符串进行反汇编时，无效的UTF-8或
// 无效的UTF-16代理项对不会被视为错误。
// 取而代之的是Unicode替换
// 字符U+FFFD。
// 
func Unmarshal(data []byte, v any) error {
	// 检查格式是否良好。
	// 避免在发现JSON语法错误之前填写半个数据结构。
	var d decodeState
	err := checkValid(data, &d.scan)
	if err != nil {
		return err
	}

	d.init(data)
	return d.unmarshal(v)
}

// 解组器是由类型
// 实现的接口，可以解组对自身的JSON描述。
// 可以假设输入是
// 的一个JSON值的有效编码。UnmarshalJSON必须复制JSON数据
// 如果它希望在返回后保留数据。
// 
// 按照惯例，为了近似解组器本身的行为，
// 解组器将解组器JSON（[]字节（“null”））实现为no-op。
type Unmarshaler interface {
	UnmarshalJSON([]byte) error
}

// 解组器类型错误描述的JSON值为
// 不适用于特定Go类型的值。
type UnmarshalTypeError struct {
	Value  string       // JSON值的描述——“bool”、“array”，“number-5”kucdefg
}

func (e *UnmarshalTypeError) Error() string {
	if e.Struct != "" || e.Field != "" {
		return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String()
	}
	return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
}

// 
// 已弃用：不再使用；为了兼容性而保留。
type UnmarshalFieldError struct {
	Key   string
	Type  reflect.Type
	Field reflect.StructField
}

func (e *UnmarshalFieldError) Error() string {
	return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
}

// InvalidUnmarshalError描述了传递给Unmarshal的无效参数。
// （Unmarshal的参数必须是非零指针。）我们解码的是房车而不是房车。Elem因为解组器接口
type InvalidUnmarshalError struct {
	Type reflect.Type
}

func (e *InvalidUnmarshalError) Error() string {
	if e.Type == nil {
		return "json: Unmarshal(nil)"
	}

	if e.Type.Kind() != reflect.Pointer {
		return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
	}
	return "json: Unmarshal(nil " + e.Type.String() + ")"
}

func (d *decodeState) unmarshal(v any) error {
	rv := reflect.ValueOf(v)
	if rv.Kind() != reflect.Pointer || rv.IsNil() {
		return &InvalidUnmarshalError{reflect.TypeOf(v)}
	}

	d.scan.reset()
	d.scanWhile(scanSkipSpace)
	// 测试必须在值的顶层应用。
	err := d.value(rv)
	if err != nil {
		return d.addErrorContext(err)
	}
	return d.savedError
}

// 一个数字代表一个JSON数字。
type Number string

// String返回数字的文本。
func (n Number) String() string { return string(n) }

// Float64将数字作为Float64返回。
func (n Number) Float64() (float64, error) {
	return strconv.ParseFloat(string(n), 64)
}

// Int64将数字作为Int64返回。
func (n Number) Int64() (int64, error) {
	return strconv.ParseInt(string(n), 10, 64)
}

// errorContext为解码期间的类型错误提供上下文。
type errorContext struct {
	Struct     reflect.Type
	FieldStack []string
}

// decodeState表示解码JSON值时的状态。
type decodeState struct {
	data                  []byte
	off                   int // 数据中的下一个读取偏移量
	opcode                int // 上次读取结果
	scan                  scanner
	errorContext          *errorContext
	savedError            error
	useNumber             bool
	disallowUnknownFields bool
}

// readIndex返回上次读取字节的位置。
func (d *decodeState) readIndex() int {
	return d.off - 1
}

// phasePanicMsg被用作一个恐慌信息，当我们最终得到一些不应该发生的事情时。它可能表示JSON解码器中存在错误，或者
// 在解码器执行时，有东西正在编辑数据片。
const phasePanicMsg = "JSON decoder out of sync - data changing underfoot?"

func (d *decodeState) init(data []byte) *decodeState {
	d.data = data
	d.off = 0
	d.savedError = nil
	if d.errorContext != nil {
		d.errorContext.Struct = nil
		// 重新使用分配给FieldStack切片的空间。
		d.errorContext.FieldStack = d.errorContext.FieldStack[:0]
	}
	return d
}

// saveError保存调用它的第一个错误，
// 以便在解组结束时报告。
func (d *decodeState) saveError(err error) {
	if d.savedError == nil {
		d.savedError = d.addErrorContext(err)
	}
}

// addErrorContext返回一个新错误，该错误使用d.errorContext中的信息进行了增强。
func (d *decodeState) addErrorContext(err error) error {
	if d.errorContext != nil && (d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0) {
		switch err := err.(type) {
		case *UnmarshalTypeError:
			err.Struct = d.errorContext.Struct.Name()
			err.Field = strings.Join(d.errorContext.FieldStack, ".")
		}
	}
	return err
}

// 跳过扫描，直到启动的内容结束。
func (d *decodeState) skip() {
	s, data, i := &d.scan, d.data, d.off
	depth := len(s.parseState)
	for {
		op := s.step(s, data[i])
		i++
		if len(s.parseState) < depth {
			d.off = i
			d.opcode = op
			return
		}
	}
}

// scanNext处理d.data[d.off]处的字节。
func (d *decodeState) scanNext() {
	if d.off < len(d.data) {
		d.opcode = d.scan.step(&d.scan, d.data[d.off])
		d.off++
	} else {
		d.opcode = d.scan.eof()
		d.off = len(d.data) + 1 // 使用len+1 
	}
}

// scanWhile处理d.data中的字节[d.off:]直到它
// 接收到一个不等于op的扫描码。
func (d *decodeState) scanWhile(op int) {
	s, data, i := &d.scan, d.data, d.off
	for i < len(data) {
		newOp := s.step(s, data[i])
		i++
		if newOp != op {
			d.opcode = newOp
			d.off = i
			return
		}
	}

	d.off = len(data) + 1 // 使用len+1 
	d.opcode = d.scan.eof()
}

// 标记处理过的EOF重新扫描与scanWhile（scanContinue）类似，但它专门处理
// 我们在解码文字时的常见情况。解码器扫描输入
// 两次，一次扫描语法错误并检查值的长度，第二次扫描
// 执行解码。
// 
// 只有在第二步中，我们才使用decodeState来标记文字，所以我们
// 知道没有任何语法错误。我们可以利用这些知识，
// 更快地扫描文本的字节。
func (d *decodeState) rescanLiteral() {
	data, i := d.data, d.off
Switch:
	switch data[i-1] {
	case '"': // 字符串
		for ; i < len(data); i++ {
			switch data[i] {
			case '\\':
				i++ // 转义字符
			case '"':
				i++ // 将结束引号标记化太
				break Switch
			}
		}
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-': // 数字
		for ; i < len(data); i++ {
			switch data[i] {
			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
				'.', 'e', 'E', '+', '-':
			default:
				break Switch
			}
		}
	case 't': // 真
		i += len("rue")
	case 'f': // 假
		i += len("alse")
	case 'n': // 空
		i += len("ull")
	}
	if i < len(data) {
		d.opcode = stateEndValue(&d.scan, data[i])
	} else {
		d.opcode = scanEnd
	}
	d.off = i + 1
}

// 值消耗d.data[d.off-1:]中的JSON值，解码为v，
// 读取前面的字节。如果v无效，则该值将被丢弃。
// 值的第一个字节已被读取。
func (d *decodeState) value(v reflect.Value) error {
	switch d.opcode {
	default:
		panic(phasePanicMsg)

	case scanBeginArray:
		if v.IsValid() {
			if err := d.array(v); err != nil {
				return err
			}
		} else {
			d.skip()
		}
		d.scanNext()

	case scanBeginObject:
		if v.IsValid() {
			if err := d.object(v); err != nil {
				return err
			}
		} else {
			d.skip()
		}
		d.scanNext()

	case scanBeginLiteral:
		// 文本中的所有字节返回scanContinue操作码。
		start := d.readIndex()
		d.rescanLiteral()

		if v.IsValid() {
			if err := d.literalStore(d.data[start:d.readIndex()], v, false); err != nil {
				return err
			}
		}
	}
	return nil
}

type unquotedValue struct{}

// valueQuoted与value类似，但将带引号的字符串literal或literal null解码为接口值。
// 如果它找到的不是带引号的字符串文字或null，
// valueQuoted返回unquotedValue{}。
func (d *decodeState) valueQuoted() any {
	switch d.opcode {
	default:
		panic(phasePanicMsg)

	case scanBeginArray, scanBeginObject:
		d.skip()
		d.scanNext()

	case scanBeginLiteral:
		v := d.literalInterface()
		switch v.(type) {
		case nil, string:
			return v
		}
	}
	return unquotedValue{}
}

// 间接遍历v，根据需要分配指针，
// 直到到达非指针。
// 如果遇到解组器，间接停止并返回该解组器。
// 如果decodingNull为true，则间接会在第一个可设置指针处停止，因此
// 可以设置为nil。
func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
	// 问题#24153表明它通常不是担保财产
	// 您可以往返a。通过调用Value来实现Value。Addr（）。Elem（）
	// 并且对于从
	// 未报告的嵌入式结构字段派生的值，该值仍然可以设置。
	// 
	// 下面的逻辑在第一次处理值
	// （以满足可能的指针方法）并继续根据需要取消对
	// 后续指针的引用时有效地实现了这一点。
	// 
	// 第一次往返后，我们将v设置回原始值以
	// 保留反射中包含的原始RW标志。价值
	v0 := v
	haveAddr := false

	// 如果v是命名类型且可寻址，则
	// 从其地址开始，这样，如果该类型具有指针方法，则
	// 我们可以找到它们。
	if v.Kind() != reflect.Pointer && v.Type().Name() != "" && v.CanAddr() {
		haveAddr = true
		v = v.Addr()
	}
	for {
		// 从接口加载值，但前提是结果是
		// 有效可寻址。
		if v.Kind() == reflect.Interface && !v.IsNil() {
			e := v.Elem()
			if e.Kind() == reflect.Pointer && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Pointer) {
				haveAddr = false
				v = e
				continue
			}
		}

		if v.Kind() != reflect.Pointer {
			break
		}

		if decodingNull && v.CanSet() {
			break
		}

		// 如果v是指向自己地址的接口，则防止无限循环：
		// var v接口{}
		// v=&v 
		if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
			v = v.Elem()
			break
		}
		if v.IsNil() {
			v.Set(reflect.New(v.Type().Elem()))
		}
		if v.Type().NumMethod() > 0 && v.CanInterface() {
			if u, ok := v.Interface().(Unmarshaler); ok {
				return u, nil, reflect.Value{}
			}
			if !decodingNull {
				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
					return nil, u, reflect.Value{}
				}
			}
		}

		if haveAddr {
			v = v0 // 在往返值后恢复原始值。Addr（）。Elem（）
			haveAddr = false
		} else {
			v = v.Elem()
		}
	}
	return nil, nil, v
}

// 数组使用来自d.data[d.off-1:]的数组，解码到v.
// 数组的第一个字节（“[”）已被读取。
func (d *decodeState) array(v reflect.Value) error {
	// 检查解组器。
	u, ut, pv := indirect(v, false)
	if u != nil {
		start := d.readIndex()
		d.skip()
		return u.UnmarshalJSON(d.data[start:d.off])
	}
	if ut != nil {
		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
		d.skip()
		return nil
	}
	v = pv

	// 检查目标类型。
	switch v.Kind() {
	case reflect.Interface:
		if v.NumMethod() == 0 {
			// 解码到nil接口？切换到非反射代码。
			ai := d.arrayInterface()
			v.Set(reflect.ValueOf(ai))
			return nil
		}
		// 否则无效。
		fallthrough
	default:
		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
		d.skip()
		return nil
	case reflect.Array, reflect.Slice:
		break
	}

	i := 0
	for {
		// 向前看]-只能在第一次迭代时发生。
		d.scanWhile(scanSkipSpace)
		if d.opcode == scanEndArray {
			break
		}

		// 获取数组元素，必要时进行增长。
		if v.Kind() == reflect.Slice {
			// 必要时增加切片
			if i >= v.Cap() {
				newcap := v.Cap() + v.Cap()/2
				if newcap < 4 {
					newcap = 4
				}
				newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
				reflect.Copy(newv, v)
				v.Set(newv)
			}
			if i >= v.Len() {
				v.SetLen(i + 1)
			}
		}

		if i < v.Len() {
			// 解码为元素。
			if err := d.value(v.Index(i)); err != nil {
				return err
			}
		} else {
			// 固定数组用完：跳过。
			if err := d.value(reflect.Value{}); err != nil {
				return err
			}
		}
		i++

		// 下一个令牌必须是，或]。
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.opcode == scanEndArray {
			break
		}
		if d.opcode != scanArrayValue {
			panic(phasePanicMsg)
		}
	}

	if i < v.Len() {
		if v.Kind() == reflect.Array {
			// 数组。剩下的归零。
			z := reflect.Zero(v.Type().Elem())
			for ; i < v.Len(); i++ {
				v.Index(i).Set(z)
			}
		} else {
			v.SetLen(i)
		}
	}
	if i == 0 && v.Kind() == reflect.Slice {
		v.Set(reflect.MakeSlice(v.Type(), 0, 0))
	}
	return nil
}

var nullLiteral = []byte("null")
var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()

// 对象使用来自d.data[d.off-1:]的对象，解码为v.
// 对象的第一个字节（“{”）已被读取。
func (d *decodeState) object(v reflect.Value) error {
	// 检查解组器。
	u, ut, pv := indirect(v, false)
	if u != nil {
		start := d.readIndex()
		d.skip()
		return u.UnmarshalJSON(d.data[start:d.off])
	}
	if ut != nil {
		d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
		d.skip()
		return nil
	}
	v = pv
	t := v.Type()

	// 解码为nil接口？切换为非反射代码。
	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
		oi := d.objectInterface()
		v.Set(reflect.ValueOf(oi))
		return nil
	}

	var fields structFields

	// 检查目标类型：
	// 结构或
	// 映射[T1]T2，其中T1是字符串、整数类型、
	// 或编码。TextUnmarshaler 
	switch v.Kind() {
	case reflect.Map:
		// 映射键必须具有字符串种类、整数种类、
		// 或是编码。文本解压器。
		switch t.Key().Kind() {
		case reflect.String,
			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		default:
			if !reflect.PointerTo(t.Key()).Implements(textUnmarshalerType) {
				d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
				d.skip()
				return nil
			}
		}
		if v.IsNil() {
			v.Set(reflect.MakeMap(t))
		}
	case reflect.Struct:
		fields = cachedTypeFields(t)
		// 好的
	default:
		d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
		d.skip()
		return nil
	}

	var mapElem reflect.Value
	var origErrorContext errorContext
	if d.errorContext != nil {
		origErrorContext = *d.errorContext
	}

	for {
		// 阅读开场白
		d.scanWhile(scanSkipSpace)
		if d.opcode == scanEndObject {
			break
		}
		if d.opcode != scanBeginLiteral {
			panic(phasePanicMsg)
		}

		// 读取密钥。
		start := d.readIndex()
		d.rescanLiteral()
		item := d.data[start:d.readIndex()]
		key, ok := unquoteBytes(item)
		if !ok {
			panic(phasePanicMsg)
		}

		// 找出与密钥对应的字段。
		var subv reflect.Value
		destring := false // 值是否包装在要首先解码的字符串中

		if v.Kind() == reflect.Map {
			elemType := t.Elem()
			if !mapElem.IsValid() {
				mapElem = reflect.New(elemType).Elem()
			} else {
				mapElem.Set(reflect.Zero(elemType))
			}
			subv = mapElem
		} else {
			var f *field
			if i, ok := fields.nameIndex[string(key)]; ok {
				// 找到了一个精确的名称匹配。
				f = &fields.list[i]
			} else {
				// 返回昂贵的不区分大小写的
				// 线性搜索。
				for i := range fields.list {
					ff := &fields.list[i]
					if ff.equalFold(ff.nameBytes, key) {
						f = ff
						break
					}
				}
			}
			if f != nil {
				subv = v
				destring = f.quoted
				for _, i := range f.index {
					if subv.Kind() == reflect.Pointer {
						if subv.IsNil() {
							// 如果结构嵌入了指向未报告类型的指针，
							// 由于该字段未报告，因此无法设置新分配的值
							// 。
							// 
							// 请参阅https:
							if !subv.CanSet() {
								d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
								// 使subv无效以确保d.value（subv）跳过
								// JSON值，而不将其分配给subv。
								subv = reflect.Value{}
								destring = false
								break
							}
							subv.Set(reflect.New(subv.Type().Elem()))
						}
						subv = subv.Elem()
					}
					subv = subv.Field(i)
				}
				if d.errorContext == nil {
					d.errorContext = new(errorContext)
				}
				d.errorContext.FieldStack = append(d.errorContext.FieldStack, f.name)
				d.errorContext.Struct = t
			} else if d.disallowUnknownFields {
				d.saveError(fmt.Errorf("json: unknown field %q", key))
			}
		}

		// 读取：在值之前。
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.opcode != scanObjectKey {
			panic(phasePanicMsg)
		}
		d.scanWhile(scanSkipSpace)

		if destring {
			switch qv := d.valueQuoted().(type) {
			case nil:
				if err := d.literalStore(nullLiteral, subv, false); err != nil {
					return err
				}
			case string:
				if err := d.literalStore([]byte(qv), subv, true); err != nil {
					return err
				}
			default:
				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
			}
		} else {
			if err := d.value(subv); err != nil {
				return err
			}
		}

		// 将值写回地图；
		// 如果使用struct，subv已经指向struct。
		if v.Kind() == reflect.Map {
			kt := t.Key()
			var kv reflect.Value
			switch {
			case reflect.PointerTo(kt).Implements(textUnmarshalerType):
				kv = reflect.New(kt)
				if err := d.literalStore(item, kv, true); err != nil {
					return err
				}
				kv = kv.Elem()
			case kt.Kind() == reflect.String:
				kv = reflect.ValueOf(key).Convert(kt)
			default:
				switch kt.Kind() {
				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
					s := string(key)
					n, err := strconv.ParseInt(s, 10, 64)
					if err != nil || reflect.Zero(kt).OverflowInt(n) {
						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
						break
					}
					kv = reflect.ValueOf(n).Convert(kt)
				case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
					s := string(key)
					n, err := strconv.ParseUint(s, 10, 64)
					if err != nil || reflect.Zero(kt).OverflowUint(n) {
						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
						break
					}
					kv = reflect.ValueOf(n).Convert(kt)
				default:
					panic("json: Unexpected key type") // 不应出现
				}
			}
			if kv.IsValid() {
				v.SetMapIndex(kv, subv)
			}
		}

		// 下一个令牌必须是，或}。
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.errorContext != nil {
			// 将errorContext重置为其原始状态。
			// 为FieldStack保留相同的底层数组，以重用
			// 空间并避免不必要的alloc。
			d.errorContext.FieldStack = d.errorContext.FieldStack[:len(origErrorContext.FieldStack)]
			d.errorContext.Struct = origErrorContext.Struct
		}
		if d.opcode == scanEndObject {
			break
		}
		if d.opcode != scanObjectValue {
			panic(phasePanicMsg)
		}
	}
	return nil
}

// convertNumber根据d.useNumber的设置，将数字文字s转换为浮点64或数字
// 。
func (d *decodeState) convertNumber(s string) (any, error) {
	if d.useNumber {
		return Number(s), nil
	}
	f, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
	}
	return f, nil
}

var numberType = reflect.TypeOf(Number(""))

// literalStore将item中存储的文字解码为v。
// 
// fromQuoted表示此文字是否来自于从“、string”结构标记选项中展开
// 字符串。这仅用于
// 生成更多有用的错误消息。
func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
	// 检查解组器。
	if len(item) == 0 {
		// 给定的空字符串
		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		return nil
	}
	isNull := item[0] == 'n' // null 
	u, ut, pv := indirect(v, isNull)
	if u != nil {
		return u.UnmarshalJSON(item)
	}
	if ut != nil {
		if item[0] != '"' {
			if fromQuoted {
				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
				return nil
			}
			val := "number"
			switch item[0] {
			case 'n':
				val = "null"
			case 't', 'f':
				val = "bool"
			}
			d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
			return nil
		}
		s, ok := unquoteBytes(item)
		if !ok {
			if fromQuoted {
				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
			}
			panic(phasePanicMsg)
		}
		return ut.UnmarshalText(s)
	}

	v = pv

	switch c := item[0]; c {
	case 'n': // null 
		// 主解析器检查只有true和false可以到达这里，
		// 但是如果这是一个带引号的字符串输入，它可能是任何内容。
		if fromQuoted && string(item) != "null" {
			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
			break
		}
		switch v.Kind() {
		case reflect.Interface, reflect.Pointer, reflect.Map, reflect.Slice:
			v.Set(reflect.Zero(v.Type()))
			// 否则，忽略原语/string 
		}
	case 't', 'f': // true，false 
		value := item[0] == 't'
		// 主解析器检查只有true和false可以到达这里，
		// 但是如果这是带引号的字符串输入，它可以是任何内容。
		if fromQuoted && string(item) != "true" && string(item) != "false" {
			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
			break
		}
		switch v.Kind() {
		default:
			if fromQuoted {
				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
			} else {
				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
			}
		case reflect.Bool:
			v.SetBool(value)
		case reflect.Interface:
			if v.NumMethod() == 0 {
				v.Set(reflect.ValueOf(value))
			} else {
				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
			}
		}

	case '"': // 字符串
		s, ok := unquoteBytes(item)
		if !ok {
			if fromQuoted {
				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
			}
			panic(phasePanicMsg)
		}
		switch v.Kind() {
		default:
			d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
		case reflect.Slice:
			if v.Type().Elem().Kind() != reflect.Uint8 {
				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
				break
			}
			b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
			n, err := base64.StdEncoding.Decode(b, s)
			if err != nil {
				d.saveError(err)
				break
			}
			v.SetBytes(b[:n])
		case reflect.String:
			if v.Type() == numberType && !isValidNumber(string(s)) {
				return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
			}
			v.SetString(string(s))
		case reflect.Interface:
			if v.NumMethod() == 0 {
				v.Set(reflect.ValueOf(string(s)))
			} else {
				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
			}
		}

	default: // 数字
		if c != '-' && (c < '0' || c > '9') {
			if fromQuoted {
				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
			}
			panic(phasePanicMsg)
		}
		s := string(item)
		switch v.Kind() {
		default:
			if v.Kind() == reflect.String && v.Type() == numberType {
				// s必须是有效数字，因为它是
				// 已标记化。
				v.SetString(s)
				break
			}
			if fromQuoted {
				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
			}
			d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
		case reflect.Interface:
			n, err := d.convertNumber(s)
			if err != nil {
				d.saveError(err)
				break
			}
			if v.NumMethod() != 0 {
				d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
				break
			}
			v.Set(reflect.ValueOf(n))

		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			n, err := strconv.ParseInt(s, 10, 64)
			if err != nil || v.OverflowInt(n) {
				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
				break
			}
			v.SetInt(n)

		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			n, err := strconv.ParseUint(s, 10, 64)
			if err != nil || v.OverflowUint(n) {
				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
				break
			}
			v.SetUint(n)

		case reflect.Float32, reflect.Float64:
			n, err := strconv.ParseFloat(s, v.Type().Bits())
			if err != nil || v.OverflowFloat(n) {
				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
				break
			}
			v.SetFloat(n)
		}
	}
	return nil
}

// xxxInterface例程建立一个值，存储在空接口中。它们并不是绝对必要的，但它们避免了这种常见情况下的反思。

// valueInterface与value相似，但返回接口{}
func (d *decodeState) valueInterface() (val any) {
	switch d.opcode {
	default:
		panic(phasePanicMsg)
	case scanBeginArray:
		val = d.arrayInterface()
		d.scanNext()
	case scanBeginObject:
		val = d.objectInterface()
		d.scanNext()
	case scanBeginLiteral:
		val = d.literalInterface()
	}
	return
}

// arrayInterface与数组相似，但返回[]接口{}。
func (d *decodeState) arrayInterface() []any {
	var v = make([]any, 0)
	for {
		// 向前看]-只能在第一次迭代时发生。
		d.scanWhile(scanSkipSpace)
		if d.opcode == scanEndArray {
			break
		}

		v = append(v, d.valueInterface())

		// 下一个令牌必须是，或]。
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.opcode == scanEndArray {
			break
		}
		if d.opcode != scanArrayValue {
			panic(phasePanicMsg)
		}
	}
	return v
}

// objectInterface类似于object，但返回map[string]接口{}。
func (d *decodeState) objectInterface() map[string]any {
	m := make(map[string]any)
	for {
		// Read opening”或closing}.
		d.scanWhile(scanSkipSpace)
		if d.opcode == scanEndObject {
			// closing}-只能在第一次迭代时发生。
			break
		}
		if d.opcode != scanBeginLiteral {
			panic(phasePanicMsg)
		}

		// Read string key.
		start := d.readIndex()
		d.rescanLiteral()
		item := d.data[start:d.readIndex()]
		key, ok := unquote(item)
		if !ok {
			panic(phasePanicMsg)
		}

		// Read:before value.
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.opcode != scanObjectKey {
			panic(phasePanicMsg)
		}
		d.scanWhile(scanSkipSpace)

		// Read value.
		m[key] = d.valueInterface()

		// 下一个标记必须是，或}和
		if d.opcode == scanSkipSpace {
			d.scanWhile(scanSkipSpace)
		}
		if d.opcode == scanEndObject {
			break
		}
		if d.opcode != scanObjectValue {
			panic(phasePanicMsg)
		}
	}
	return m
}

// 它在前面读取以下字节。文本的第一个字节是
// read read read read read（这就是调用方知道它是文本的方式）。
func (d *decodeState) literalInterface() any {
	// 文本中的所有字节返回scanContinue操作代码。
	start := d.readIndex()
	d.rescanLiteral()

	item := d.data[start:d.readIndex()]

	switch c := item[0]; c {
	case 'n': // null 
		return nil

	case 't', 'f': // true，false 
		return c == 't'

	case '"': // string 
		s, ok := unquote(item)
		if !ok {
			panic(phasePanicMsg)
		}
		return s

	default: // number 
		if c != '-' && (c < '0' || c > '9') {
			panic(phasePanicMsg)
		}
		n, err := d.convertNumber(string(item))
		if err != nil {
			d.saveError(err)
		}
		return n
	}
}

// getu4从s开始解码\uxxx，返回十六进制值，
// 或返回-1。
func getu4(s []byte) rune {
	if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
		return -1
	}
	var r rune
	for _, c := range s[2:6] {
		switch {
		case '0' <= c && c <= '9':
			c = c - '0'
		case 'a' <= c && c <= 'f':
			c = c - 'a' + 10
		case 'A' <= c && c <= 'F':
			c = c - 'A' + 10
		default:
			return -1
		}
		r = r*16 + rune(c)
	}
	return r
}

// unquote将带引号的JSON字符串文本s转换为实际的字符串t。
// 规则与Go不同，因此不能使用strconv。取消报价。
func unquote(s []byte) (t string, ok bool) {
	s, ok = unquoteBytes(s)
	t = string(s)
	return
}

func unquoteBytes(s []byte) (t []byte, ok bool) {
	if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
		return
	}
	s = s[1 : len(s)-1]

	// 检查有无异常字符。如果没有，
	// 则不需要取消引用，因此返回
	// 原始字节的一部分。
	r := 0
	for r < len(s) {
		c := s[r]
		if c == '\\' || c == '"' || c < ' ' {
			break
		}
		if c < utf8.RuneSelf {
			r++
			continue
		}
		rr, size := utf8.DecodeRune(s[r:])
		if rr == utf8.RuneError && size == 1 {
			break
		}
		r += size
	}
	if r == len(s) {
		return s, true
	}

	b := make([]byte, len(s)+2*utf8.UTFMax)
	w := copy(b, s[0:r])
	for r < len(s) {
		// 离开房间？只有在s中充满了格式错误的UTF-8，并且我们将每个
		// 字节替换为RuneError时，才会发生这种情况。
		if w >= len(b)-2*utf8.UTFMax {
			nb := make([]byte, (len(b)+utf8.UTFMax)*2)
			copy(nb, b[0:w])
			b = nb
		}
		switch c := s[r]; {
		case c == '\\':
			r++
			if r >= len(s) {
				return
			}
			switch s[r] {
			default:
				return
			case '"', '\\', '/', '\'':
				b[w] = s[r]
				r++
				w++
			case 'b':
				b[w] = '\b'
				r++
				w++
			case 'f':
				b[w] = '\f'
				r++
				w++
			case 'n':
				b[w] = '\n'
				r++
				w++
			case 'r':
				b[w] = '\r'
				r++
				w++
			case 't':
				b[w] = '\t'
				r++
				w++
			case 'u':
				r--
				rr := getu4(s[r:])
				if rr < 0 {
					return
				}
				r += 6
				if utf16.IsSurrogate(rr) {
					rr1 := getu4(s[r:])
					if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
						// 一对有效；消费
						r += 6
						w += utf8.EncodeRune(b[w:], dec)
						break
					}
					// 代理无效；回到替换符文。
					rr = unicode.ReplacementChar
				}
				w += utf8.EncodeRune(b[w:], rr)
			}

		// 引号，控制字符无效。
		case c == '"', c < ' ':
			return

		// ASCII 
		case c < utf8.RuneSelf:
			b[w] = c
			r++
			w++

		// 强制使用格式良好的UTF-8。
		default:
			rr, size := utf8.DecodeRune(s[r:])
			r += size
			w += utf8.EncodeRune(b[w:], rr)
		}
	}
	return b[0:w], true
}
